BFS——迷宫问题小结

定义一个二维数组：

int maze[5][5] = {

0, 1, 0, 0, 0,

0, 1, 0, 1, 0,

0, 0, 0, 0, 0,

0, 1, 1, 1, 0,

0, 0, 0, 1, 0,

};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。
Input
一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。
Output
左上角到右下角的最短路径，格式如样例所示。
Sample Input
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
Sample Output
(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)
问题总结：

（一）对于用BFS来解决迷宫问题（最快走出迷宫的方法），要用到的“工具”，

1. 一个存放迷宫点的结构体队列，例如该题的结构体要存点的坐标和上一个点的轨迹；
2. 一个标记数组，用来标记该点有没有走过；
3. 一个方向数组，根据题意的不同有的是四个方向（本题），还有的是八个方向；

（二）要用到的逻辑判断

1. 要判断BFS什么时候退出循环，例如本题如果队列里没有元素了或者走出迷宫了（到达（4.4）这个点了）
2. 判断加上方向后的点是否符合要求（是否超过数组边界即迷宫边界）；

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct node
{
    int x;
    int y;
    int front;
}link[240], t, p;
int flag[10][10];
int map[10][10];
int f[12][12] = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
int judge(int x, int y)
{
    if(x < 0 || y < 0 || y > 4 || x > 4)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}
void bfs()
{
    int i;
    int start  = 0;int end = 0;
    link[end].x = 0;
    link[end].y = 0;
    link[end++].front = -1;
    flag[0][0] = 1;
    while(start < end)
    {
        t = link[start];
        if(t.x == 4 && t.y == 4)
        {
            break;
        }
        for(i = 0; i < 4; i++)
        {
            p.x = t.x + f[i][0];
            p.y = t.y + f[i][1];
            p.front = start;
            if(judge(p.x, p.y) && flag[p.x][p.y] == 0 && map[p.x][p.y] == 0)
            {
                flag[p.x][p.y] = 1;
                link[end++] = p;
            }
        }
        start++;
    }
    struct node ans[240];
    int k = 0;
    while(start != -1)
    {
        ans[k++] = link[start];
        start = link[start].front;
    }
    for(i = k - 1; i>= 0; i--)
    {
        printf("(%d, %d)\n", ans[i].x, ans[i].y);
    }
}
int main()
{
    int i, j;
    memset(flag, 0, sizeof(flag));
    for(i = 0; i < 5; i++)
    {
        for(j = 0; j < 5; j++)
        {
            scanf("%d", &map[i][j]);
        }
    }
    bfs();
    return 0;
}